#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include "estructuras.h"
#include "constantes.h"
#include "listas.h"

int AgregarAColaDePedidosADisco(struct ListaIDdescriptors ** pnodo, struct ListaIDdescriptors ** ListaDeIDPedidos, struct ListaIDdescriptors ** ListaDeIDPedidos_Ult )
{
	if((*ListaDeIDPedidos) == NULL)
	{
		(*pnodo)->Ant = NULL;
		(*pnodo)->Sgt = NULL;
		(*ListaDeIDPedidos) = (*pnodo);
	}	
	else
	{
		(*pnodo)->Ant = *ListaDeIDPedidos_Ult;	
		(*pnodo)->Sgt = NULL;
		(*ListaDeIDPedidos_Ult)->Sgt = (*pnodo);
	}
	
	*ListaDeIDPedidos_Ult=*pnodo;
}

void imprimirCola(struct ListaIDdescriptors *ptrActual){

   if(ptrActual==NULL)
      printf("La cola esta vacia\n");

   else{
   
		printf("La Cola es: \n");
		while(ptrActual!=NULL){ 
			printf("%i->",ptrActual->sector);
			/*printf("data %s\n",ptrActual->data);*/
			ptrActual=ptrActual->Sgt;  
		}
		printf("NULL \n");  
   }
   
} 


void imprimirColaClientes(listaPFS *ptrActual){

   if(ptrActual==NULL)
      printf("La cola esta vacia\n");

   else{
   
		printf("La Cola es: \n");
		while(ptrActual!=NULL){ 
			printf("%i->",ptrActual->iSocket);
			/*printf("data %s\n",ptrActual->data);*/
			ptrActual=ptrActual->Sgt;  
		}
		printf("NULL \n");  
   }
   
} 

/*
struct ListaIDdescriptors * SacarNodoDescriptoresDeLista(struct ListaIDdescriptors ** ListaDeIDPedidos, struct ListaIDdescriptors ** ListaDeIDPedidos_Ult)
{
	struct ListaIDdescriptors * temp;
	
	temp=*ListaDeIDPedidos;
	*ListaDeIDPedidos=(*ListaDeIDPedidos)->Sgt;
	if(*ListaDeIDPedidos == NULL){
      *ListaDeIDPedidos_Ult=NULL;
	}
	return temp;
	
}
*/


struct ListaIDdescriptors * SacarNodoDescriptoresDeLista(struct ListaIDdescriptors ** ListaDeIDPedidos, struct ListaIDdescriptors ** ListaDeIDPedidos_Ult,struct ListaIDdescriptors ** listaSegundaPasada)
{
	struct ListaIDdescriptors * temp;

	if((*listaSegundaPasada)!=NULL)
		(*listaSegundaPasada)->Sgt = (*listaSegundaPasada);

	temp=*ListaDeIDPedidos;
	*ListaDeIDPedidos=(*ListaDeIDPedidos)->Sgt;
	if(*ListaDeIDPedidos == NULL){
      *ListaDeIDPedidos_Ult=NULL;
	}

	if(*ListaDeIDPedidos==(*listaSegundaPasada))
		(*listaSegundaPasada) = NULL;
	return temp;

}

int estaVacia(struct ListaIDdescriptors * ListaDeIDPedidos){

   return ListaDeIDPedidos==NULL;

}

int longitud(struct ListaIDdescriptors *  ptrActual) {
	
	int n=0;
	
	while (ptrActual != NULL) {  
      ++n;
	   ptrActual = ptrActual->Sgt;
	}
	return n;

}




void insertarSegunAlgoritmo(struct ListaIDdescriptors ** pnodo, struct ListaIDdescriptors ** ListaDeIDPedidos, struct ListaIDdescriptors ** ListaDeIDPedidos_Ult,int posicionCabezal,int modo)
{

	 if((estaVacia(* ListaDeIDPedidos)))
	 {
		 *ListaDeIDPedidos= *pnodo;
		 *ListaDeIDPedidos_Ult= *pnodo;
	 }
	 else
	 {
		 if(modo==0)
		 {
			 if(posicionCabezal > (*pnodo)->sector)
			 {
				 if((*ListaDeIDPedidos_Ult)->sector < (*pnodo)->sector)
				 {
					 (* ListaDeIDPedidos_Ult)->Sgt=(* pnodo);
					 (* pnodo)->Ant=(* ListaDeIDPedidos_Ult);
					 (* ListaDeIDPedidos_Ult)=(* pnodo);
				 }
				 else
				 {
					 struct ListaIDdescriptors *aux=(*ListaDeIDPedidos_Ult);
					 while((aux->Ant!=NULL)&&(aux->sector > (* pnodo)->sector)&&(aux->sector < posicionCabezal ))
						 aux=aux->Ant;

					 if(aux->Ant==NULL) {


						 if( (*ListaDeIDPedidos)->Sgt!=NULL)
							 (*ListaDeIDPedidos)->Sgt->Ant=*pnodo;
						 else
						 	(*ListaDeIDPedidos_Ult)=*pnodo;

						 (*pnodo)->Sgt=(*ListaDeIDPedidos)->Sgt;
						 (*ListaDeIDPedidos)->Sgt=*pnodo;
						 (*pnodo)->Ant=*ListaDeIDPedidos;



					 }
					 else{
						if(aux->Sgt!=NULL){
							(* pnodo)->Sgt=aux->Sgt;
							aux->Sgt->Ant=(* pnodo);
							aux->Sgt=(* pnodo);
							(* pnodo)->Ant=aux;
						}
						else
						{
							 (* ListaDeIDPedidos_Ult)->Sgt=(* pnodo);
							 (* pnodo)->Ant=(* ListaDeIDPedidos_Ult);
							(* ListaDeIDPedidos_Ult)=(* pnodo);
						}
				 	 }
				 }
			 }
			 else
			 {
				 if((*ListaDeIDPedidos)->sector > (*pnodo)->sector)
				 {
					 (* ListaDeIDPedidos)->Ant=(*pnodo);
					 (* pnodo)->Sgt=(*ListaDeIDPedidos);
					 (* ListaDeIDPedidos)=(*pnodo);
				 }
				 else
				 {
					 struct ListaIDdescriptors *aux=(*ListaDeIDPedidos);

					 while((aux->Sgt != NULL) && (aux->sector < (* pnodo)->sector) && (aux->sector >= posicionCabezal)){
						 aux=aux->Sgt;

					 }

					 if((aux->Sgt == NULL))
					 {
						if((* ListaDeIDPedidos) != aux)
						{
							 if(aux->sector < (* pnodo)->sector){
								 (* ListaDeIDPedidos_Ult)->Sgt=(* pnodo);
								 (* pnodo)->Ant=(* ListaDeIDPedidos_Ult);
								 (* ListaDeIDPedidos_Ult)=(* pnodo);
							 }
							 else{

								 aux->Ant->Sgt=* pnodo;
								 (* pnodo)->Ant= aux->Ant;
								 aux->Ant= (* pnodo);
								 (* pnodo)->Sgt=aux;
							 }
						 }
						 else
						 {
							 if((*ListaDeIDPedidos)->sector > (*pnodo)->sector)
							 {
								 (* ListaDeIDPedidos)->Ant=(*pnodo);
								 (* pnodo)->Sgt=(*ListaDeIDPedidos);
								 (* ListaDeIDPedidos)=(*pnodo);
							 }
							 else
							 {
								 (* ListaDeIDPedidos)->Sgt =  (*pnodo);
								 (*pnodo)->Ant = (* ListaDeIDPedidos);
								 (*pnodo)->Sgt = NULL;
								 (* ListaDeIDPedidos)->Ant = NULL;
							 }


						 }



					 }
					 else
					 {

						 printf("aux->sector %i \n",aux->sector);

						 if(aux->Ant!=NULL) {
							 aux->Ant->Sgt=(* pnodo);
							 (*pnodo)->Ant=aux->Ant;
							 aux->Ant=(* pnodo);
							 (*pnodo)->Sgt=aux;

						 }
						 else{
							 (* pnodo)->Sgt=aux->Sgt;
							 aux->Sgt->Ant=(* pnodo);
							 aux->Sgt=(* pnodo);
							 (* pnodo)->Ant=aux;
						 }

					 }
				}
			 }

		 }



		 if(modo==1)
		{
			 if(posicionCabezal > (*pnodo)->sector)
			 {
				 if((*ListaDeIDPedidos_Ult)->sector > (*pnodo)->sector)
				 {
					 (* ListaDeIDPedidos_Ult)->Sgt=(* pnodo);
					 (* pnodo)->Ant=(* ListaDeIDPedidos_Ult);
					 (* ListaDeIDPedidos_Ult)=(* pnodo);
				 }
				 else
				 {
					 struct ListaIDdescriptors *aux=(*ListaDeIDPedidos_Ult);
					 while((aux->Ant!=NULL)&&(aux->sector < (* pnodo)->sector)&&(aux->sector < posicionCabezal ))
						 aux=aux->Ant;

					 if(aux->Ant==NULL) {


						 if( (*ListaDeIDPedidos)->Sgt!=NULL)
							 (*ListaDeIDPedidos)->Sgt->Ant=*pnodo;
						 else
							(*ListaDeIDPedidos_Ult)=*pnodo;

						 (*pnodo)->Sgt=(*ListaDeIDPedidos)->Sgt;
						 (*ListaDeIDPedidos)->Sgt=*pnodo;
						 (*pnodo)->Ant=*ListaDeIDPedidos;



					 }
					 else{
						if(aux->Sgt!=NULL){
							(* pnodo)->Sgt=aux->Sgt;
							aux->Sgt->Ant=(* pnodo);
							aux->Sgt=(* pnodo);
							(* pnodo)->Ant=aux;
						}
						else
						{
							 (* ListaDeIDPedidos_Ult)->Sgt=(* pnodo);
							 (* pnodo)->Ant=(* ListaDeIDPedidos_Ult);
							(* ListaDeIDPedidos_Ult)=(* pnodo);
						}
					 }
				 }
			 }
			 else
			 {
				 if((*ListaDeIDPedidos)->sector > (*pnodo)->sector)
				 {
					 (* ListaDeIDPedidos)->Ant=(*pnodo);
					 (* pnodo)->Sgt=(*ListaDeIDPedidos);
					 (* ListaDeIDPedidos)=(*pnodo);
				 }
				 else
				 {
					 struct ListaIDdescriptors *aux=(*ListaDeIDPedidos);



					 while((aux->Sgt != NULL) && (aux->sector < (* pnodo)->sector) && (aux->sector >= posicionCabezal)){
						 aux=aux->Sgt;

					 }

					 if((aux->Sgt == NULL))
					 {


						 if(aux->sector < (* pnodo)->sector){
							 (* ListaDeIDPedidos_Ult)->Sgt=(* pnodo);
							 (* pnodo)->Ant=(* ListaDeIDPedidos_Ult);
							 (* ListaDeIDPedidos_Ult)=(* pnodo);
						 }
						 else{

							 aux->Ant->Sgt=* pnodo;
							 (* pnodo)->Ant= aux->Ant;
							 aux->Ant= (* pnodo);
							 (* pnodo)->Sgt=aux;
						 }


					 }
					 else
					 {


						 if(aux->Ant!=NULL) {
							 aux->Ant->Sgt=(* pnodo);
							 (*pnodo)->Ant=aux->Ant;
							 aux->Ant=(* pnodo);
							 (*pnodo)->Sgt=aux;

						 }
						 else{
							 (* pnodo)->Sgt=aux->Sgt;
							 aux->Sgt->Ant=(* pnodo);
							 aux->Sgt=(* pnodo);
							 (* pnodo)->Ant=aux;
						 }

					 }
				}
			 }

		 }

	 }
}



int buscarTrace(int sector)
{
	int posicion=0;
	int faltan=0;
	int i;

	while(VectorTrace[posicion]!=sector)
	{
		posicion++;
	}
	
	
	for(i=0;i<5;i++){
		if((VectorTrace[i]!=sector)&&(VectorTrace[i]!=-1))
			faltan++;
	}	
	
	VectorTrace[posicion]=-1;
	
	if(faltan>=1)	
		return 1;
	else
		return 0;
} 


void Insertar(struct ListaIDdescriptors ** pnodo, struct ListaIDdescriptors ** ListaDeIDPedidos, struct ListaIDdescriptors ** ListaDeIDPedidos_Ult,struct ListaIDdescriptors ** listaSegundaPasada)
 {


	//lo agrego
	if((estaVacia(* ListaDeIDPedidos))){
		(* ListaDeIDPedidos) = (* pnodo);
		*ListaDeIDPedidos_Ult=*pnodo;
		return;
	}
	//si es menor al primero lo agrego primero
	if((* pnodo)->sector < (* ListaDeIDPedidos)->sector){
		(* ListaDeIDPedidos)->Ant = (* pnodo);
		(* pnodo)->Sgt = (* ListaDeIDPedidos);
		(* ListaDeIDPedidos) = (* pnodo);
		return;
	}
	//si es mayor al primero lo agrego ordenado o antes de la segunda pasada
	if((* pnodo)->sector > (* ListaDeIDPedidos)->sector)
	{
		listaIDDescriptors *anterior = (* ListaDeIDPedidos_Ult);


		if((*listaSegundaPasada) != NULL)
		{
			while((anterior->Ant!=NULL) && anterior->Ant->sector > (* pnodo)->sector && anterior->Sgt != (*listaSegundaPasada))
			{
				anterior = anterior->Ant;
			}
		}
		else
		{
			while((anterior->Ant!=NULL) && anterior->Ant->sector > (* pnodo)->sector)
			{
				anterior = anterior->Ant;
			}
		}
		if(anterior->Sgt != NULL)
			anterior->Sgt->Ant = (*pnodo);
		(* pnodo)->Sgt = anterior->Sgt;
		anterior->Sgt = (* pnodo);
		(* pnodo)->Ant=anterior;


		if(((*pnodo)->Sgt==NULL))
			*ListaDeIDPedidos_Ult=*pnodo;

		return;
	}
 }

void InsertarSegundaPasada (struct ListaIDdescriptors ** pnodo, struct ListaIDdescriptors ** ant, struct ListaIDdescriptors ** segundaPasada,struct ListaIDdescriptors ** ult)
{
	if((*segundaPasada)==NULL)
	{
		(*pnodo)->Sgt = NULL;
		(*pnodo)->Ant = (*ant);
		(*ult)->Sgt = (*pnodo);
		(*segundaPasada)=*pnodo;
		*ult=*pnodo;
	}
	else
	{
		if((*pnodo)->sector < (*segundaPasada)->sector)
		{
			(*pnodo)->Ant = (*segundaPasada)->Ant;
			(*segundaPasada)->Ant->Sgt = (*pnodo);
			(*pnodo)->Sgt = (*segundaPasada);
			(*segundaPasada)->Ant = (*pnodo);
			(*segundaPasada)=*pnodo;
		}
		else
		{
			listaIDDescriptors *anterior = (*segundaPasada);
			while((anterior->Sgt!=NULL) && anterior->Sgt->sector <= (* pnodo)->sector)
			{
				anterior = anterior->Sgt;
			}

			(* pnodo)->Sgt = anterior->Sgt;
			anterior->Sgt = (* pnodo);
			(* pnodo)->Ant=anterior;

			if(((*pnodo)->Sgt==NULL))
				*ult=*pnodo;
			else
				(*pnodo)->Sgt->Ant = (*pnodo);
		}

	}

}


int agregarAListaDeClientes(listaPFS ** pnodo, listaPFS ** LClientes, listaPFS ** LClientes_Ult)			/*Agrega el nodo a la lista ListaDiscos (enlazar) */
{


	if((*LClientes) == NULL)
	{
		(*pnodo)->Ant = NULL;
		(*pnodo)->Sgt = NULL;
		(*LClientes) = (*pnodo);
	}
	else
	{
		(*pnodo)->Ant = (*LClientes_Ult);
		(*pnodo)->Sgt = NULL;
		(*LClientes_Ult)->Sgt = (*pnodo);
	}

	(*LClientes_Ult)=*pnodo;

}


int	SacarDeLista_Clientes(listaPFS ** nodo, listaPFS ** LClientes, listaPFS ** LClientes_Ult)	  /*solo desenalzar el nodo de la lista sin liberar*/
{

if(  ((*nodo)->Ant == NULL) && ((*nodo)->Sgt == NULL)  )
	{
	(*LClientes_Ult) = NULL;
	(*LClientes) = NULL;

	}
else if(  ((*nodo)->Ant == NULL) && ((*nodo)->Sgt != NULL)  )
	{
	*LClientes = (*nodo)->Sgt;
	(*LClientes)->Ant = NULL;
	}

else if(  ((*nodo)->Ant != NULL) && ((*nodo)->Sgt == NULL)  )
	{

	(*LClientes_Ult) = (*nodo)->Ant;
	(*LClientes_Ult)->Sgt = NULL;

	}
else if(  ((*nodo)->Ant != NULL) && ((*nodo)->Sgt != NULL)  )
	{
	(*nodo)->Ant->Sgt=(*nodo)->Sgt;
	(*nodo)->Sgt->Ant=(*nodo)->Ant;

	}

return 0;


}




void insertarSegunAlg(struct ListaIDdescriptors ** pnodo, struct ListaIDdescriptors ** ListaDeIDPedidos, struct ListaIDdescriptors ** ListaDeIDPedidos_Ult,struct ListaIDdescriptors **segundaPasada,int posicionCabezal,int modo)
{
	 if((estaVacia(* ListaDeIDPedidos)))
	 {
		 *ListaDeIDPedidos= *pnodo;
		 *ListaDeIDPedidos_Ult= *pnodo;
	 }
	 else
	 {
		 if(posicionCabezal <= (*pnodo)->sector)
			 Insertar(&(*pnodo),&(*ListaDeIDPedidos),&(*ListaDeIDPedidos_Ult),&(*segundaPasada));
		 else
		 {
			 struct ListaIDdescriptors * ant;
			 if((*segundaPasada) == NULL)
				ant = (*ListaDeIDPedidos_Ult);
			 else
				 ant = (*segundaPasada)->Ant;

	 	 	 InsertarSegundaPasada(&(*pnodo),&ant,&(*segundaPasada),&(*ListaDeIDPedidos_Ult));
		 }
	 }
}

/*

void Insertar (struct ListaIDdescriptors ** pnodo, struct ListaIDdescriptors ** ListaDeIDPedidos, struct ListaIDdescriptors ** ListaDeIDPedidos_Ult,struct ListaIDdescriptors ** listaSegundaPasada)
 {


	//lo agrego
	if((estaVacia(* ListaDeIDPedidos))){
		(* ListaDeIDPedidos) = (* pnodo);
		*ListaDeIDPedidos_Ult=*pnodo;
		return;
	}
	//si es menor al primero lo agrego primero
	if((* pnodo)->sector < (* ListaDeIDPedidos)->sector){
		(* ListaDeIDPedidos)->Ant = (* pnodo);
		(* pnodo)->Sgt = (* ListaDeIDPedidos);
		(* ListaDeIDPedidos) = (* pnodo);
		return;
	}
	//si es mayor al primero lo agrego ordenado o antes de la segunda pasada
	if((* pnodo)->sector > (* ListaDeIDPedidos)->sector)
	{
		listaIDDescriptors *anterior = (* ListaDeIDPedidos);



		if((*listaSegundaPasada) != NULL)
		{
			while((anterior->Sgt!=NULL) && anterior->Sgt->sector <= (* pnodo)->sector && anterior->sector != (*listaSegundaPasada)->Ant->sector)
			{
				anterior = anterior->Sgt;
			}
		}
		else
		{
			while((anterior->Sgt!=NULL) && anterior->Sgt->sector <= (* pnodo)->sector)
			{
				anterior = anterior->Sgt;
			}
		}
		if(anterior->Sgt != NULL)
			anterior->Sgt->Ant = (*pnodo);
		(* pnodo)->Sgt = anterior->Sgt;
		anterior->Sgt = (* pnodo);
		(* pnodo)->Ant=anterior;


		if(((*pnodo)->Sgt==NULL))
			*ListaDeIDPedidos_Ult=*pnodo;

		return;
	}
 }

void InsertarSegundaPasada (struct ListaIDdescriptors ** pnodo, struct ListaIDdescriptors ** ant, struct ListaIDdescriptors ** segundaPasada,struct ListaIDdescriptors ** ult)
{
	if((*segundaPasada)==NULL)
	{
		(*pnodo)->Sgt = NULL;
		(*pnodo)->Ant = (*ant);
		(*ult)->Sgt = (*pnodo);
		(*segundaPasada)=*pnodo;
	}
	else
	{
		if((*pnodo)->sector < (*segundaPasada)->sector)
		{
			(*pnodo)->Ant = (*segundaPasada)->Ant;
			(*segundaPasada)->Ant->Sgt = (*pnodo);
			(*pnodo)->Sgt = (*segundaPasada);
			(*segundaPasada)->Ant = (*pnodo);
			(*segundaPasada)=*pnodo;
		}
		else
		{
			listaIDDescriptors *anterior = (*segundaPasada);
			while((anterior->Sgt!=NULL) && anterior->Sgt->sector <= (* pnodo)->sector)
			{
				anterior = anterior->Sgt;
			}

			(* pnodo)->Sgt = anterior->Sgt;
			anterior->Sgt = (* pnodo);
			(* pnodo)->Ant=anterior;

			if(((*pnodo)->Sgt==NULL))
				*ult=*pnodo;
		}

	}

}




void insertarSegunAlg(struct ListaIDdescriptors ** pnodo, struct ListaIDdescriptors ** ListaDeIDPedidos, struct ListaIDdescriptors ** ListaDeIDPedidos_Ult,struct ListaIDdescriptors **segundaPasada,int posicionCabezal,int modo)
{
	 if((estaVacia(* ListaDeIDPedidos)))
	 {
		 *ListaDeIDPedidos= *pnodo;
		 *ListaDeIDPedidos_Ult= *pnodo;
	 }
	 else
	 {
		 if(posicionCabezal <= (*pnodo)->sector)
			 Insertar(&(*pnodo),&(*ListaDeIDPedidos),&(*ListaDeIDPedidos_Ult),&(*segundaPasada));
		 else
		 {
			 struct ListaIDdescriptors * ant;
			 if((*segundaPasada) == NULL)
				ant = (*ListaDeIDPedidos_Ult);
			 else
				 ant = (*segundaPasada)->Ant;

	 	 	 InsertarSegundaPasada(&(*pnodo),&ant,&(*segundaPasada),&(*ListaDeIDPedidos_Ult));
		 }
	 }
}*/

